Exemplary embodiments of the present invention relate to systems of interconnected computer systems, and more particularly, to asynchronous process interaction between computer systems integrated within an overall system of interconnected systems.
In information technology (IT) systems that integrate multiple interconnected, heterogeneous software systems in which the executing process flows and tasks for each individual system are interrelated with the internal state of the overall system, the interconnected systems have a need to interact with one another. In one aspect of interaction between the interconnected systems, the internal states for the processes being executed by the different system are dependent on process flows and tasks executing throughout the overall system (that is, the internal state for a process being executed by one of the interconnected systems can change as a result of the execution of process flows and tasks on other systems interconnected within the overall system). In another aspect, the execution of process flows and tasks by the interconnected systems is dependent on the state of the overall system (for example, a dependency where a system must be in a certain state for a process flow to continue). Nevertheless, each of the interconnected systems integrated within the overall system may have its own particular implementation for state handling, inter-process communication, and synchronous and asynchronous job execution. As a result, interfaces must be implemented to provide for communication between the systems, for example, where two systems need to communicate with one another to track the progress of external states, to wait for the end of external tasks to synchronize their own processing, or to be notified by event messages transmitted by external tasks upon a state change.
One common IT architectural implementation for systems of multiple, interconnected computer systems that has been increasing in importance recently provides for the systems to be integrated so as to contribute to a higher-level business flow. In systems implemented according to this architecture, the execution can be described according to the client-server model of computer process interaction. More particularly, a high-level process flow is executed by a control flow system (the client system), and the individual stages of the high-level process flow are performed by other individual systems (the server systems) integrated within the overall system. In particular, at various points during execution of the high-level process flow, the control flow client system will invoke another of the interconnected systems to execute the actual functionality for the concrete operations performed during a certain stage in the high-level process flow. The operations performed during a certain stage in the high-level process flow by the invoked system may involve an isolated, primitive task, or the invoked system may operate in a manner similar to the control flow client system to direct execution of a complex process flow in which the system directing the complex process flow (now viewed as the client system) will invoke another of the interconnected systems as a server system to execute the actual functionality for the concrete operations performed during a certain stage in the complex process flow. In this manner, the high-level business process flow performed by the overall system integrating the heterogeneous systems can be executed using a nested chain of interconnected systems executing higher-level functionality to act as client systems to systems that act as server systems to provide lower-level functionality.
In existing implementations of such integrated systems, the needed interconnections between the individual systems are provided for using a synchronous messaging pattern (for example, the control flow execution directed by the client system “waits” for each call made to another system to return before continuing to execute). The correlation between the combined flows performed in the individual stages as described above is performed unique task identifiers such as IDs, tickets, etc. For example, when a system directing a control flow acts as a client to invoke another system as a server to execute some task, the server system may return a ticket that identifies the specific instance of the invoked process being executed, and the client then waits for the specific process instance identified by the returned ticket to complete. Where the interconnected systems in such a system are homogeneous (same type, same vendor, etc.), the coupling and correlation of the interrelated tasks and flows provided by each interacting system can be performed quite easily because the homogeneous systems will generally use the same mechanisms for identifying tasks or for notifying one another. This is particularly true where the combined flows are executed within a single system.
The coupling and correlation in an implementation providing a heterogeneous system of interconnected systems, however, imposes implementation challenges because the mechanisms of task identification and notification differ among interacting systems. With respect to task identification, it will often be the case that completely different information domains are used for identifying tasks by the different integrated systems. Domains of different interconnected systems are not trivial to correlate. In particular, with respect to notification mechanisms, it is a challenge to couple the communication channels used by the systems to one another because they may rely on different, incompatible protocols for communication. In certain situations, for example, the callback protocols offered by a system acting as a server may be different from those understood by the calling system acting as the client. In other situations, a system called as a server may not even be configured to provide any notification mechanisms, in which case the systems acting as clients must actively poll the server system for task completion. Situations such as these can involve a large overhead cost for developing the binding implementation.